Instead of catching the KeyError, we can simplify this by using a safe lookup on stages_dict. Something like:

instance = stages_dict.get(cls.__name__)
if instance is not None:
    return instance, False

instance = stages_dict[cls.__name__] = cls()
return instance, True

This method is nice and improves some inefficiencies in the previous logic (eg, processing the same stage more than once).

I think, if we move the only_stages logic here, we can avoid re-iterating over the stages_dict logic (between lines 543-546).
Something like:

if only_stages:
    if cls.__name__ not in only_stages:
        instance.skipped = True

This logic looks more concise than the previous implementation. @folded, I've included a few differences I've noticed between the new logic and the previous implementation. Here, I did a 1:1 comparison, but if these changes are intentional, feel free to skip my comment.

(In the workflow examples, -> points to the execution order and not the edge direction in the DAG object)

1. When last_stages contains multiple stages on the same path, the previous logic picks the downstream stage (to skip the stages further downstream).
   Let's say we have a workflow A -> B -> C -> D. If we define last_stages = [B, C], the previous logic skips only D, but the new logic will skip C, D.

This happens when B becomes a shadow caster with shadowed={C, D}.

2. Stage skipping when both last_stages and first_stages are defined.
   Let's say we have a workflow with first_stages = B and last_stages=F

A->C
 ->B->D
    ->E->F->G  
    ->G

The previous logic will result in,

B->D
 ->E->F

But in the new logic,

• A will not be skipped - Even though B is a shadow caster, C will light up A and the last_stage kept logic will include A.
• Gwill not be skipped - Even though F is a shadow caster, E will light-up G and the first_stage kept logic will include G.